package com.suning.sawp.service.util;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.URLDecoder;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.common.base.Strings;
import com.suning.sawp.constants.ConfigConstants;
import com.suning.sawp.dto.customer.CustshopFrequency;
import com.suning.sawp.service.custProtrait.SignatureData;

/**
 * 
 * 一些字符处理的util方法<br>
 * 〈功能详细描述〉
 *
 * @author 12061818
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class DJStringUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(DJStringUtils.class);

    private DJStringUtils() {

    }

    public static final String DEFAULT_NAME = "顾客";

    public static final String DEFAULT_PLACEHOLDER = "*";

    public static final String DEFAULT_SEPARATOR = ";";

    // gson转换
    public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final Gson GSON = new GsonBuilder().setDateFormat(DATE_FORMAT).enableComplexMapKeySerialization()
            .create();

    static final Pattern P_EMAIL = Pattern
            .compile("^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@" + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$");
    static final Pattern P_PHONE = Pattern.compile("^(1\\d{2})\\d{8}$");

    private static final String[] FBS_ARR = { "\\", "$", "(", ")", "*", "+", ".", "[", "]", "?", "^", "{", "}", "|" };

    /**
     * 除数保留3位小数
     */
    public static final int SCALE_THREE = 3;

    /**
     * 除数保留2位小数
     */
    public static final int SCALE_TWO = 2;

    /**
     * 保留1位小数
     */
    public static final int SCALE_ONE = 1;

    /**
     * 数字10
     */
    public static final int TEN = 10;

    /**
     * 数字50
     */
    public static final int FIFTY = 50;

    /**
     * 100数值
     */
    public static final String ONE_HUNDRED = "100";

    public static boolean testPhone(String str) {
        return P_PHONE.matcher(str).matches();
    }

    public static boolean testEmail(String str) {
        return P_EMAIL.matcher(str).matches();
    }

    /**
     * 
     * 功能描述: <br>
     * 敏感信息隐藏处理
     * 
     * @param sensitiveTxt 敏感信息
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String sensitiveHandle(String sensitiveTxt) {
        // ①手机号，显示前三位与后二位，中间六位用*****显示，如18651661111，则显示186******11
        // ②邮箱，除邮箱后缀全显示，前面部分显示三分之一的位数，向上取整
        // 如a@126.com，则显示a@126.com （除后缀以外显示位数为三分之一向上取整，即显示1位）
        // 如aa@126.com，则显示a*@126.com（除后缀以外显示位数为三分之二向上取整，即显示1位）
        // 如aaa@126.com，则显示a**@126.com（除后缀以外显示位数为1，即显示1位）
        // 如aaaa@126.com，则显示aa**@126.com（除后缀以外显示位数为三分之四向上取整，即显示2位）
        // ③其他（有可能为昵称、门店会员卡号登陆用户），小于4位不显示，否则显示前两位与最后一位，中间位数全部用*表示，如“朱佳佳的易购账号”，显示“朱佳*****号”，“025300400100”，显示“02**********0”

        if (testPhone(sensitiveTxt)) {
            return sensitiveTxt.replaceAll("\\b(\\d{3})\\d+(\\d{2})", "$1******$2");
        } else if (testEmail(sensitiveTxt)) {
            Pattern emailMask = Pattern.compile("\\b([^@]+)@(\\S+\\.[^\\s.]+)");
            Matcher m = emailMask.matcher(sensitiveTxt);
            if (m.find()) {
                String part1 = m.group(1);
                return Strings.padEnd("" + part1.subSequence(0, (int) Math.ceil(part1.length() / 3.0)), part1.length(),
                        '*') + "@" + m.group(2);
            } else {
                return sensitiveTxt;
            }
        } else {
            if (sensitiveTxt.length() < 4) {
                return "";
            } else {
                String head = sensitiveTxt.substring(0, 2);
                String tail = sensitiveTxt.substring(sensitiveTxt.length() - 1, sensitiveTxt.length());
                return Strings.padEnd(head, sensitiveTxt.length() - 1, '*') + tail;
            }

        }

    }

    /**
     * 
     * 敏感信息隐藏处理(除前m个和最后n个字符, 其他字符用*替代)
     * 
     * @param sensitiveTxt 敏感信息 空串则返回空
     * @param m 最前面m个字符不脱敏 必须大于0
     * @param n 最后面n个字符不脱敏 必须大于0
     * @return 处理后的字符串
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String sensitiveHandleEx(String sensitiveTxt, int m, int n) {
        if (StringUtils.isBlank(sensitiveTxt)) {
            return "";
        } else if (sensitiveTxt.length() <= m + n) {
            return sensitiveTxt;
        } else {
            String head = sensitiveTxt.substring(0, m);
            String tail = sensitiveTxt.substring(sensitiveTxt.length() - n);
            return Strings.padEnd(head, sensitiveTxt.length() - n, '*') + tail;
        }
    }

    /**
     * 
     * 功能描述: 对手机号做脱敏操作<br>
     * 〈功能详细描述〉
     *
     * @param mobile
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String desensitiseMobile(String mobile) {
        return sensitiveHandleEx(mobile, 3, 2);
    }

    /**
     * 
     * 功能描述: <br>
     * 按区间生成随机数
     * 
     * @param min
     * @param max
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int random(int min, int max) {
        return Math.abs(UUID.randomUUID().toString().hashCode() % max) + min;
    }

    /**
     * 
     * 功能描述: <br>
     * String类型数据进行小数点后两位的格式化
     * 
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String stringFormat(String num) {
        if (StringUtils.isEmpty(num)) {
            return num;
        }
        BigDecimal b = new BigDecimal(num);
        String result = b.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
        return result;
    }

    /**
     * 
     * 功能描述: 正则表达式特殊字符转义<br>
     * 〈功能详细描述〉
     *
     * @param keyword
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String escapeExprSpecialWord(String orgKeyword) {
        String keyword = orgKeyword;
        if (StringUtils.isNotBlank(keyword)) {
            for (String key : FBS_ARR) {
                if (keyword.contains(key)) {
                    keyword = keyword.replace(key, "\\" + key);
                }
            }
        }
        return keyword;
    }

    /**
     * 
     * 功能描述: 拼接会员画像的URL<br>
     * 〈功能详细描述〉
     *
     * @param custNo
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getMemberProtraitUrl(String custNo) {
        String custUrl = ConfigUtil.getConfig(ConfigConstants.SAWP_CONFIG_PATH, ConfigConstants.CUST_PROTRAIT_URL);

        if (StringUtils.isBlank(custUrl)) {
            LOGGER.warn("getMemberProtraitUrl custUrl is null");
            return null;
        }
        try {
            // url decode
            custUrl = URLDecoder.decode(custUrl, "UTF-8");

            LOGGER.debug("decode url, custUrl=" + custUrl);
        } catch (UnsupportedEncodingException e) {
            LOGGER.warn("URLDecoder failed", e);
        }

        String priKey = ConfigUtil.getConfig(ConfigConstants.SAWP_CONFIG_PATH, ConfigConstants.CUST_PROTRAIT_URL_SK);
        String url = SignatureData.wrapMemberProtraitUrl(custUrl, custNo, priKey);
        LOGGER.debug("getMemberProtraitUrl,url=" + url);

        return url;
    }

    public static String setDecimal(double money) {
        return String.format("%.2f", money);
    }

    /**
     * 
     * 功能描述: <br>
     * 两个字则姓以*号展示名明文展示，三个字及以上，隐藏中间字用星号代替，为空则展示“顾客”
     *
     * @param name
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String desensitiseName(String name) {
        if (StringUtils.isBlank(name)) {
            name = DEFAULT_NAME;
        } else {
            int length = name.length();
            if (length <= 2) {
                name = DEFAULT_PLACEHOLDER + name.substring(1, length);
            } else {
                name = name.substring(0, 1) + StringUtils.repeat(DEFAULT_PLACEHOLDER, length - 2)
                        + name.substring(length - 1, length);
            }
        }
        return name;
    }

    /**
     * 
     * 功能描述: <br>
     * oms 八段地址脱敏<br>
     * 收货地址部分展示，城市、区域明文展示，详细地址部分：若字数＞3，则从第二个字至倒数第3个字隐藏；若字数为3，则隐藏中间一个字；若字数≤2，则均隐藏；隐藏部分均以*号代替，其余明文展示 <br>
     * 收货地址取自八段地址中的第二段（市）、第三段（区）、第四段（县）及第八段（详细地址），例如：;;宁波市;鄞州区;全区;;;;万达苏宁四楼三星冰洗专柜
     *
     * 
     * @param address
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String desensitiseOmsAddress(String address) {
        if (StringUtils.isBlank(address)) {
            address = StringUtils.EMPTY;
        } else {
            String[] addresses = address.split(DEFAULT_SEPARATOR);
            String addressDetail = DEFAULT_PLACEHOLDER;
            if (addresses.length >= 9) {
                String tmp = addresses[8];
                int tmpLength = tmp.length();
                if (tmpLength <= 2) {
                    addressDetail = StringUtils.repeat(DEFAULT_PLACEHOLDER, tmpLength);
                } else if (tmpLength == 3) {
                    addressDetail = tmp.substring(0, 1) + DEFAULT_PLACEHOLDER + tmp.substring(tmpLength - 1, tmpLength);
                } else {
                    addressDetail = tmp.substring(0, 1) + StringUtils.repeat(DEFAULT_PLACEHOLDER, tmpLength - 3)
                            + tmp.substring(tmpLength - 2, tmpLength);
                }
            }
            address = addresses[2] + addresses[3] + addresses[4] + addressDetail;

        }
        return address;
    }

    public static CustshopFrequency getDealType(String frequency) {
        int count = 0;
        if (StringUtils.isNotBlank(frequency)) {
            try {
                count = Integer.parseInt(frequency);
            } catch (NumberFormatException e) {
                LOGGER.warn("NumberFormatException", e);
            }
        }

        String text = CustshopFrequency.DealTypeText.NO_BUY;
        String dealType = CustshopFrequency.DealType.NO_BUY;
        if (count > 1) {
            text = CustshopFrequency.DealTypeText.MORE_BUY;
            dealType = CustshopFrequency.DealType.MORE_BUY;
        }
        if (count == 1) {
            text = CustshopFrequency.DealTypeText.FIRST_BUY;
            dealType = CustshopFrequency.DealType.FIRST_BUY;
        }

        return new CustshopFrequency(dealType, text);
    }

    /**
     * 
     * 功能描述: 邮箱脱敏<br>
     * 〈功能详细描述〉
     *
     * @param email
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String desensitiseEmail(String email) {
        StringBuilder desensitizeEmail = new StringBuilder("");
        if (StringUtils.isNotBlank(email)) {
            Matcher matcher = P_EMAIL.matcher(email);
            if (matcher.matches()) {
                String[] args = email.split("\\@");
                String desensitise = sensitiveHandleEx(args[0], 2, 1);
                desensitizeEmail.append(desensitise).append("@").append(args[1]);
            }
        }

        return desensitizeEmail.toString();
    }

    /**
     * 计算比率，返回string
     *
     * @param model
     * @param total
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String calculateRateString(String model, String total) {
        LOGGER.info("DJStringUtils.calculateRateString,model={},total={}", model, total);
        BigDecimal rate = calculateRate(model, total);
        LOGGER.debug("DJStringUtils.calculateRateString rate={}", rate);
        return rate.setScale(BigDecimal.ONE.intValue(), BigDecimal.ROUND_DOWN).toString();
    }

    /**
     * 计算比率
     *
     * @param model
     * @param total
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    private static BigDecimal calculateRate(String model, String total) {
        LOGGER.info("DJStringUtils.calculateRate,model={},total={}", model, total);
        if (NumberUtils.isNumber(model) && NumberUtils.isNumber(total)) {
            // string 转数值类型
            BigDecimal decimalmodel = new BigDecimal(model);
            BigDecimal decimaltotal = new BigDecimal(total);
            try {
                // 保留3位小数, 并乘以一百
                if (BigDecimal.ZERO.compareTo(decimaltotal) != 0) {
                    return decimalmodel.divide(decimaltotal, SCALE_THREE, BigDecimal.ROUND_HALF_EVEN)
                            .multiply(new BigDecimal(ONE_HUNDRED));
                }
            } catch (Exception e) {
                LOGGER.error("DJStringUtils.calculateRate error,", e);
            }
        }
        return BigDecimal.ZERO;
    }

    /**
     * 计算比率
     *
     * @param model
     * @param total
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static BigDecimal calculateRate(BigDecimal model, BigDecimal total) {
        LOGGER.info("DJStringUtils.calculateRate,model={},total={}", model, total);
        if (null != model && null != total && BigDecimal.ZERO.compareTo(total) != 0) {
            try {
                // 保留3位小数, 并乘以一百
                return model.divide(total, SCALE_THREE, BigDecimal.ROUND_HALF_EVEN);
            } catch (Exception e) {
                LOGGER.error("DJStringUtils.calculateRate error,", e);
            }
        }
        return BigDecimal.ZERO;
    }

    public static BigDecimal calculateRatePercent(BigDecimal model, BigDecimal total) {
        LOGGER.info("DJStringUtils.calculateRate,model={},total={}", model, total);
        if (null != model && null != total && BigDecimal.ZERO.compareTo(total) != 0) {
            try {
                // 保留3位小数, 并乘以一百
                return model.divide(total, SCALE_THREE, BigDecimal.ROUND_HALF_EVEN)
                        .multiply(new BigDecimal(ONE_HUNDRED)).setScale(SCALE_ONE);
            } catch (Exception e) {
                LOGGER.error("DJStringUtils.calculateRate error,", e);
            }
        }
        return new BigDecimal("0.0");
    }

    /**
     * 计算比率，返回double
     *
     * @param model
     * @param total
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static double calculateRateDouble(String model, String total) {
        LOGGER.info("DJStringUtils.calculateRateDouble,model={},total={}", model, total);
        BigDecimal rate = calculateRate(model, total);
        LOGGER.debug("DJStringUtils.calculateRateDouble rate={}", rate);
        return rate.setScale(BigDecimal.ONE.intValue(), BigDecimal.ROUND_DOWN).doubleValue();
    }
    
    /**
     * 计算金额
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param divisor
     * @param dividend
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static BigDecimal divide(BigDecimal divisor, BigDecimal dividend) {
        LOGGER.info("DJStringUtils.divide,divisor={},dividend={}", divisor, dividend);
        if (null != divisor && null != dividend && BigDecimal.ZERO.compareTo(dividend) != 0) {
            try {
                // 保留2位小数
                return divisor.divide(dividend, SCALE_TWO, BigDecimal.ROUND_HALF_EVEN);
            } catch (Exception e) {
                LOGGER.error("DJStringUtils.divide error,", e);
            }
        }
        return new BigDecimal("0.00");
    }

    /**
     * 将数字保留两位小数
     *
     * @param value
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getTwoScale(String value) {
        LOGGER.info("DJStringUtils.getTwoScale,value={}", value);
        if (NumberUtils.isNumber(value)) {
            BigDecimal decimalValue = new BigDecimal(value);
            return decimalValue.setScale(SCALE_TWO, BigDecimal.ROUND_DOWN).toString();
        }
        return "0.00";
    }
    
    /**
     * 将数字保留1位小数
     *
     * @param value
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getOneScale(String value) {
        LOGGER.info("DJStringUtils.getOneScale,value={}", value);
        if (NumberUtils.isNumber(value)) {
            BigDecimal decimalValue = new BigDecimal(value);
            return decimalValue.setScale(SCALE_ONE, BigDecimal.ROUND_DOWN).toString();
        }
        return "0.0";
    }

    /**
     * 加法运算 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param number1
     * @param number2
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String addition(String number1, String number2) {
        LOGGER.info("DJStringUtils.calculateRate,number1={},number2={}", number1, number2);
        if (NumberUtils.isNumber(number1) && NumberUtils.isNumber(number2)) {
            // string 转数值类型
            BigDecimal bd1 = new BigDecimal(number1);
            BigDecimal bd2 = new BigDecimal(number2);
            // 保留2位小数, 并乘以一百
            return bd1.add(bd2).setScale(SCALE_TWO, BigDecimal.ROUND_DOWN).toString();
        }
        return "0.00";
    }
    
    public static String additionEx(String number1, String number2) {
        LOGGER.info("DJStringUtils.additionEx,number1={},number2={}", number1, number2);
        BigDecimal bd1 = new BigDecimal(0);
        BigDecimal bd2 = new BigDecimal(0);
        if (NumberUtils.isNumber(number1)) {
            bd1 =  new BigDecimal(number1);
        }
        
        if (NumberUtils.isNumber(number2)) {
            bd2 =  new BigDecimal(number2);
        }
        
        return String.valueOf(bd1.add(bd2).intValue());
    }

    /**
     * 减法运算 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param number1
     * @param number2
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String subtraction(String number1, String number2) {
        LOGGER.info("DJStringUtils.calculateRate,number1={},number2={}", number1, number2);
        if (NumberUtils.isNumber(number1) && NumberUtils.isNumber(number2)) {
            // string 转数值类型
            BigDecimal bd1 = new BigDecimal(number1);
            BigDecimal bd2 = new BigDecimal(number2);

            // 保留2位小数, 并乘以一百
            return bd1.subtract(bd2).setScale(SCALE_TWO, BigDecimal.ROUND_DOWN).toString();
        }
        return "0.00";
    }
    
    public static String subtractionEx(String number1, String number2) {
        LOGGER.info("DJStringUtils.subtractionEx,number1={},number2={}", number1, number2);
        BigDecimal bd1 = new BigDecimal(0);
        BigDecimal bd2 = new BigDecimal(0);
        if (NumberUtils.isNumber(number1)) {
            bd1 =  new BigDecimal(number1);
        }
        
        if (NumberUtils.isNumber(number2)) {
            bd2 =  new BigDecimal(number2);
        }
        // 保留2位小数, 并乘以一百
        return String.valueOf(bd1.subtract(bd2).setScale(SCALE_TWO, BigDecimal.ROUND_DOWN).intValue()) ;
    }

    /**
     * 初始化当前页数
     *
     * @param currIndex
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int initCurrIndex(Integer currIndex) {
        if (null != currIndex && currIndex > 0) {
            return currIndex.intValue();
        }
        return 0;
    }

    /**
     * 初始化页码
     *
     * @param pageNo
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int initPageNo(Integer pageNo) {
        if (null != pageNo && pageNo > 0) {
            return pageNo.intValue();
        }
        return 1;
    }

    /**
     * 根据页码和页大小计算位置
     * 
     * @param pageNo
     * @param pageSize
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int initCurrIndex(Integer pageNo, Integer pageSize) {
        return (initPageNo(pageNo) - 1) * initPageSize(pageSize);
    }

    /**
     * 初始化页码大小
     *
     * @param pageSize
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int initPageSize(Integer pageSize) {
        // 不为空且数字小于50,否则返回默认10
        if (null != pageSize && pageSize <= FIFTY) {
            return pageSize.intValue();
        }
        // 默认返回10条大小
        return TEN;
    }

    /**
     * 
     * 功能描述: 计算同比<br>
     * 〈功能详细描述〉
     *
     * @param currentData
     * @param lastData
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static BigDecimal calculateYoy(BigDecimal currentData, BigDecimal lastData) {
        if (null != lastData && null != currentData && BigDecimal.ZERO.compareTo(lastData) != 0) {
            return currentData.subtract(lastData).divide(lastData.abs(), 3, RoundingMode.HALF_UP);
        }
        return null;
    }

    public static BigDecimal calculateYoyPercent(BigDecimal currentData, BigDecimal lastData) {
        if (null != lastData && null != currentData && BigDecimal.ZERO.compareTo(lastData) != 0) {
            return currentData.subtract(lastData).divide(lastData.abs(), 3, RoundingMode.HALF_UP)
                    .multiply(new BigDecimal(ONE_HUNDRED)).setScale(BigDecimal.ONE.intValue(), BigDecimal.ROUND_DOWN);
        }
        return new BigDecimal("0.0");
    }

    /**
     * 计算同比,返回字符串 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param currentData
     * @param lastData
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String calculateYoyString(BigDecimal currentData, BigDecimal lastData) {
        if (null != lastData && null != currentData && BigDecimal.ZERO.compareTo(lastData) != 0) {
            return currentData.subtract(lastData).divide(lastData.abs(), SCALE_THREE, BigDecimal.ROUND_HALF_EVEN)
                    .multiply(new BigDecimal(ONE_HUNDRED)).setScale(BigDecimal.ONE.intValue(), BigDecimal.ROUND_DOWN)
                    .toString();
        }
        return "0.0";
    }
    
    /**
     * 格式化BigDecimal
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param amount
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static BigDecimal bigDecimal(String amount) {
        if (StringUtils.isNotBlank(amount)) {
            try {
                return new BigDecimal(amount);
            } catch (Exception e) {
                LOGGER.error("convert BigDecimal error, amount=" + amount, e);
            }
        }
        return bigDecimal("0.0");
    }
    
    /**
     * 格式化销量
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param volumn
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String formatVolume(Object volumn) {
        if (null != volumn) {
            try {
                return String.valueOf(new BigDecimal(String.valueOf(volumn)).longValue());
            } catch (Exception e) {
                LOGGER.error("convert formatVolumn error, volumn=" + volumn, e);
            }
        }
        return "0";
    }
    
    /**
     * 查询IP地址
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param request
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getUserIp(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        boolean forwardFlag = hasDeepIp(ip);
        if (forwardFlag) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        boolean proxClientFlag = hasDeepIp(ip);
        if (proxClientFlag) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        boolean wlProxyClient = hasDeepIp(ip);
        if (wlProxyClient) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        boolean httpClientFlag = hasDeepIp(ip);
        if (httpClientFlag) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        boolean httpXforwardFlag = hasDeepIp(ip);
        if (httpXforwardFlag) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
    
    /**
     * 判断IP地址是否合法
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param ip
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    private static boolean hasDeepIp(String ip) {
        return ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip);
    }
    
    /**
     * 
     * 功能描述: 数字字符串转换成int类型字符串<br>
     * 〈功能详细描述〉
     *
     * @param value
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String transIntergerStr(String value){
        if (StringUtils.isBlank(value)) {
            return "0";
        }
        int num = 0;
        try {
            num = bigDecimal(value).intValue();
        } catch (Exception e) {
            LOGGER.error("transIntergerStr error:", e);
        }
        return String.valueOf(num);
    }
    
    /**
     * 
     * 功能描述: bigDecimal转化成int<br>
     * 〈功能详细描述〉
     *
     * @param value
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int bigDecimal2Int(BigDecimal value) {
        LOGGER.info("bigDecimal2Int. value:" + value);
        if (null != value) {
            try {
                return value.intValue();
            } catch (Exception e) {
                LOGGER.error("bigDecimal2Int failed.", e);
            }
        }
        return 0;
    }
    
    /**
     * 
     * 功能描述: bigDecimal转化成int字符串<br>
     * 〈功能详细描述〉
     *
     * @param value
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String bigDecimal2IntStr(BigDecimal value) {
        LOGGER.info("bigDecimal2IntStr. value:" + value);
        try {
            return String.valueOf(bigDecimal2Int(value));
        } catch (Exception e) {
            LOGGER.error("bigDecimal2IntStr failed.", e);
        }
        return "0";
    }
    
}
